﻿using System;
using System.Collections;
using System.Linq;
using System.Text;
using System.IO;
using Tibet.Entidades;


namespace Tibet.Logica
{
    class LogicaReglaLLaves : Regla
    {
         //Atributos

        private int _tipo;

 
        //Propiedades

        public int Tipo
        {
            get { return _tipo; }
            set { _tipo = value; }
        }
       
        //Metodos
        public LogicaReglaLLaves(int tipo)
        {
            //Constructor
            Tipo = tipo; 
        }
        override public Resultado Aplicar(ArrayList archivo)
        {
            try
            {
                if (Tipo == 1)
                     return regla_LLavesSolas(archivo);
                if (Tipo == 2) 
                    return regla_LLavesJuntas(archivo);
                if (Tipo == 3)
                    return regla_LLavesCompJS(archivo);
                if (Tipo == 4)
                    return regla_LLavesCompSJ(archivo);
                return null;
            }
            catch (Exception e)
            {
                return null;
            }
        }

        public Resultado regla_LLavesCompSJ(ArrayList archivo)
        //Este Metodo valida que se utilize la regla de llaves separadas para la llave que abre ( { ) y la regla de llaves juntas para la que cierra ( } ).
        //Ejemplo: 
        //          Metodo(){             
        //               codigo;
        //          }
        //                  
        {
            int LineaActual = 0; //Linea actual que se esta leyendo.
            Resultado Resp = new Resultado(); //Objeto resultado que sera retornado.
            string[] subcadena;

            //Inicializamos Resp asumiendo que el archivo cumple con la regla.
            Resp.Fecha = new DateTime();
            Resp.Fecha = DateTime.Now;
            Resp.Respuesta = true;
            Resp.Mensaje = "No se encontraron errores.";
            Resp.Linea = 0;
            try
            {
                foreach (string Linea in archivo) //Recorremos el archiv linea a linea
                {
                    LineaActual++; //Contamos la linea
                    subcadena = Linea.Split('{'); //Separamos la cadena en fragmentos utilizando {  como separadores
                    if (subcadena.Length == 2 && Linea.Split('}').Length == 1) //Si solo existen 2 diviciones quiere decir que hay una sola llave
                    {
                        if (subcadena[0].Length != 0 || subcadena[1].Length != 0) //Si ambos fragmentos no contienen caracteres significa que la llave esta sola.
                        {
                            Resp.Linea = LineaActual;
                            Resp.Respuesta = false;
                            Resp.Mensaje = "Existe una llave mal colocada en la linea " + LineaActual;
                            return Resp;
                        }
                    }
                    //NOTA: si existe 1 división significa que no existen llaves en esa linea,
                    //y si existen mas de 2 asumimos que esta definiendo un arreglo.
                    subcadena = Linea.Split('}');
                    if (subcadena.Length == 2) //Si solo existen 2 diviciones quiere decir que hay una sola llave
                    {
                        if (subcadena[0].Length == 0 && subcadena[1].Length == 0) //Si algun fragmentos contienene caracteres significa que la llave no esta sola.
                        {
                            Resp.Linea = LineaActual;
                            Resp.Respuesta = false;
                            Resp.Mensaje = "Existe una llave mal colocada en la linea " + LineaActual;
                            return Resp;
                        }
                    }

                }
                return Resp;
            }
            catch (Exception e)
            {
                Resp.Linea = LineaActual;
                Resp.Respuesta = false;
                Resp.Mensaje = "Ocurrio un error inesperado al leer la linea " + LineaActual + ". Error " + e.Message;
                return Resp;
            }
        }

        public Resultado regla_LLavesCompJS(ArrayList archivo)
        //Este Metodo valida que se utilize la regla de llaves juntas para la llave que abre ( { ) y la regla de llaves separadas para la que cierra ( } ).
        //Ejemplo: 
        //          Metodo(){             
        //               codigo;
        //          }
        //                  
        {
            int LineaActual = 0; //Linea actual que se esta leyendo.
            Resultado Resp = new Resultado(); //Objeto resultado que sera retornado.
            string[] subcadena;

            //Inicializamos Resp asumiendo que el archivo cumple con la regla.
            Resp.Fecha = new DateTime();
            Resp.Fecha = DateTime.Now;
            Resp.Respuesta = true;
            Resp.Mensaje = "No se encontraron errores.";
            Resp.Linea = 0;
            try
            {
                foreach (string Linea in archivo) //Recorremos el archiv linea a linea
                {
                    LineaActual++; //Contamos la linea
                    subcadena = Linea.Split('{' ); //Separamos la cadena en fragmentos utilizando {  como separadores
                    if (subcadena.Length == 2) //Si solo existen 2 diviciones quiere decir que hay una sola llave
                    {
                        if (subcadena[0].Length == 0 && subcadena[1].Length == 0) //Si ambos fragmentos no contienen caracteres significa que la llave esta sola.
                        {
                            Resp.Linea = LineaActual;
                            Resp.Respuesta = false;
                            Resp.Mensaje = "Existe una llave mal colocada en la linea " + LineaActual;
                            return Resp;
                        }
                    }
                    //NOTA: si existe 1 división significa que no existen llaves en esa linea,
                    //y si existen mas de 2 asumimos que esta definiendo un arreglo.
                    subcadena = Linea.Split('}');
                    if (subcadena.Length == 2 && Linea.Split('{').Length == 1) //Si solo existen 2 diviciones quiere decir que hay una sola llave
                    {
                        if (subcadena[0].Length != 0 || subcadena[1].Length != 0) //Si algun fragmentos contienene caracteres significa que la llave no esta sola.
                        {
                            Resp.Linea = LineaActual;
                            Resp.Respuesta = false;
                            Resp.Mensaje = "Existe una llave mal colocada en la linea " + LineaActual;
                            return Resp;
                        }
                    }

                }
                return Resp;
            }
            catch (Exception e)
            {
                Resp.Linea = LineaActual;
                Resp.Respuesta = false;
                Resp.Mensaje = "Ocurrio un error inesperado al leer la linea " + LineaActual + ". Error " + e.Message;
                return Resp;
            }
        }

        public Resultado regla_LLavesJuntas(ArrayList archivo)
        //Este Metodo valida si las llaves estan puestas en la misma linea donde termina el codigo.
        //Ejemplo: 
        //          Metodo(){             
        //               codigo;}
        //                  
        {
            int LineaActual = 0; //Linea actual que se esta leyendo.
            Resultado Resp = new Resultado(); //Objeto resultado que sera retornado.
            string[] subcadena;

            //Inicializamos Resp asumiendo que el archivo cumple con la regla.
            Resp.Fecha = new DateTime();
            Resp.Fecha = DateTime.Now;
            Resp.Respuesta = true;
            Resp.Mensaje = "No se encontraron errores.";
            Resp.Linea = 0;
            try
            {
                foreach (string Linea in archivo) //Recorremos el archiv linea a linea
                {
                    LineaActual++; //Contamos la linea
                    subcadena = Linea.Split('{', '}'); //Separamos la cadena en fragmentos utilizando { } como separadores
                    if (subcadena.Length == 2) //Si solo existen 2 diviciones quiere decir que hay una sola llave
                    {
                        if (subcadena[0].Length == 0 && subcadena[1].Length == 0) //Si ambos fragmentos no contienen caracteres significa que la llave esta sola.
                        {
                            Resp.Linea = LineaActual;
                            Resp.Respuesta = false;
                            Resp.Mensaje = "Existe una llave mal colocada en la linea " + LineaActual;
                            return Resp;
                        }
                    }
                    //NOTA: si existe 1 división significa que no existen llaves en esa linea,
                    //y si existen mas de 2 asumimos que esta definiendo un arreglo.

                }
                return Resp;
            }
            catch (Exception e)
            {
                Resp.Linea = LineaActual;
                Resp.Respuesta = false;
                Resp.Mensaje = "Ocurrio un error inesperado al leer la linea " + LineaActual + ". Error " + e.Message;
                return Resp;
            }
        }

        public Resultado regla_LLavesSolas(ArrayList archivo)
            //Este Metodo valida si las llaves estan puestas en una sola linea sin nada que las acompañe
            //Ejemplo: 
            //          Metodo()
            //                  {
            //                      codigo;
            //                  }
        {
            int LineaActual = 0; //Linea actual que se esta leyendo.
            Resultado Resp = new Resultado(); //Objeto resultado que sera retornado.
            string[] subcadena;

            //Inicializamos Resp asumiendo que el archivo cumple con la regla.
            Resp.Fecha = new DateTime();
            Resp.Fecha = DateTime.Now;
            Resp.Respuesta = true;
            Resp.Mensaje = "No se encontraron errores.";
            Resp.Linea = 0;
            try
            {
                foreach (string Linea in archivo) //Recorremos el archiv linea a linea
                {
                    LineaActual++; //Contamos la linea
                    subcadena = Linea.Split('{', '}'); //Separamos la cadena en fragmentos utilizando { } como separadores
                    if (subcadena.Length == 2) //Si solo existen 2 diviciones quiere decir que hay una sola llave
                    {
                        if (subcadena[0].Length != 0 || subcadena[1].Length != 0) //Si algun fragmento contiene caracteres significa que la llave no esta sola en la linea.
                        {
                            Resp.Linea = LineaActual;
                            Resp.Respuesta = false;
                            Resp.Mensaje = "Existe una llave mal colocada en la linea " + LineaActual;
                            return Resp;
                        }
                    } 
                    //NOTA: si existe 1 división significa que no existen llaves en esa linea,
                    //y si existen mas de 2 asumimos que esta definiendo un arreglo.
                    
                }
                return Resp;
            }
            catch (Exception e)
            {
                Resp.Linea = LineaActual;
                Resp.Respuesta = false;
                Resp.Mensaje = "Ocurrio un error inesperado al leer la linea " + LineaActual + ". Error " + e.Message;
                return Resp;
            }
        }
    }
}
